//
// A smart pointer class for reference counted objects.  Use this class instead
// of calling AddRef and Release manually on a reference counted object to
// avoid common memory leaks caused by forgetting to Release an object
// reference.  Sample usage:
//
//   class MyFoo : public RefCounted<MyFoo> {
//    ...
//   };
//
//   void some_function() {
//     scoped_refptr<MyFoo> foo = new MyFoo();
//     foo->Method(param);
//     // |foo| is released when this function returns
//   }
//
//   void some_other_function() {
//     scoped_refptr<MyFoo> foo = new MyFoo();
//     ...
//     foo = NULL;  // explicitly releases |foo|
//     ...
//     if (foo)
//       foo->Method(param);
//   }
//
// The above examples show how scoped_refptr<T> acts like a pointer to T.
// Given two scoped_refptr<T> classes, it is also possible to exchange
// references between the two objects, like so:
//
//   {
//     scoped_refptr<MyFoo> a = new MyFoo();
//     scoped_refptr<MyFoo> b;
//
//     b.swap(a);
//     // now, |b| references the MyFoo object, and |a| references NULL.
//   }
//
// To make both |a| and |b| in the above example reference the same MyFoo
// object, simply use the assignment operator:
//
//   {
//     scoped_refptr<MyFoo> a = new MyFoo();
//     scoped_refptr<MyFoo> b;
//
//     b = a;
//     // now, |a| and |b| each own a reference to the same MyFoo object.
//   }
//

#ifndef BASE_SCOPED_REF_PTR_H_
#define BASE_SCOPED_REF_PTR_H_

namespace base {

	template <class T>
	class scoped_refptr {
	public:
		scoped_refptr() : ptr_(NULL) {
		}

		scoped_refptr(T* p) : ptr_(p) {
			if (ptr_)
				ptr_->AddRef();
		}

		scoped_refptr(const scoped_refptr<T>& r) : ptr_(r.ptr_) {
			if (ptr_)
				ptr_->AddRef();
		}

		template <typename U>
		scoped_refptr(const scoped_refptr<U>& r) : ptr_(r.get()) {
			if (ptr_)
				ptr_->AddRef();
		}

		~scoped_refptr() {
			if (ptr_)
				ptr_->Release();
		}

		T* get() const { return ptr_; }
		operator T*() const { return ptr_; }
		T* operator->() const { return ptr_; }

		// Release a pointer.
		// The return value is the current pointer held by this object.
		// If this object holds a NULL pointer, the return value is NULL.
		// After this operation, this object will hold a NULL pointer,
		// and will not own the object any more.
		T* release() {
			T* retVal = ptr_;
			ptr_ = NULL;
			return retVal;
		}

		scoped_refptr<T>& operator=(T* p) {
			// AddRef first so that self assignment should work
			if (p)
				p->AddRef();
			if (ptr_ )
				ptr_ ->Release();
			ptr_ = p;
			return *this;
		}

		scoped_refptr<T>& operator=(const scoped_refptr<T>& r) {
			return *this = r.ptr_;
		}

		template <typename U>
		scoped_refptr<T>& operator=(const scoped_refptr<U>& r) {
			return *this = r.get();
		}

		void swap(T** pp) {
			T* p = ptr_;
			ptr_ = *pp;
			*pp = p;
		}

		void swap(scoped_refptr<T>& r) {
			swap(&r.ptr_);
		}

	protected:
		T* ptr_;
	};

}  // namespace base

#endif  // BASE_SCOPED_REF_PTR_H_
